PlutoTest.jl

👀 Reading hidden code

164 μs

This notebook introduces visual testing:

👀 Reading hidden code

215 μs

3.0

== 3

👀 Reading hidden code

@test sqrt(20-11) == 3

12.7 ms

iseven(

)

👀 Reading hidden code

@test iseven(123 + 7^3)

5.7 ms

∈

Int64

👀 Reading hidden code

@test 4+4 ∈ [1:7...]

33.8 ms

👀 Reading hidden code

66.1 μs

👀 Reading hidden code

65.8 μs

is_good_boy(

)

👀 Reading hidden code

@test is_good_boy(first(friends))

32.5 ms

Tests have time-travel functionality built in! Click on the tests above.

👀 Reading hidden code

256 μs

Time travel

👀 Reading hidden code

166 μs

This notebook contains visual debugging:

👀 Reading hidden code

213 μs

Error message

UndefVarError: plot not defined

Stack trace

Here is what happened, the most recent locations are first:

eval
from boot.jl:373

seval

from Other cell: line 4

	results = Any[]		seval(ex) = Computed(Core.eval(m,ex))		# will be modified

Show more...

@visual_debug begin

(1+2) + (7-6)

plot(2000 .+ 30 .* rand(2+2))

4+5

sqrt(sqrt(sqrt(5)))

md"# Wow"

end

👀 Reading hidden code

---

👀 Reading hidden code

16.5 μs

👀 Reading hidden code

495 ms

👀 Reading hidden code

342 ms

👀 Reading hidden code

371 μs

(You need `Pluto#main` to run this notebook)

👀 Reading hidden code

176 μs

toc()

👀 Reading hidden code

10.9 ms

Int64

x = [1,3]

👀 Reading hidden code

14.7 μs

Int64

@test x == [1,2+2]

👀 Reading hidden code

19.4 ms

missing

== 2

@test missing == 2

👀 Reading hidden code

61.0 ms

@test 2+2 == 2+2

👀 Reading hidden code

618 μs

Float64

0.0902303

0.735005

0.536793

0.654047

0.170118

0.895947

0.657815

0.705666

0.997585

0.158081

0.918667

0.308976

0.125568

0.159368

0.493538

0.994795

0.146627

0.643642

0.547981

0.194379

0.0260783

0.647428

0.0302074

0.497938

0.826832

0.0956063

0.036913

0.84084

0.76434

0.867522

Any

Float64

0.636591

0.682675

0.246418

0.891337

0.0838079

0.798857

0.636498

0.770244

0.452577

0.901059

@test rand(50) == [rand(50),2]

👀 Reading hidden code

67.7 ms

always_false(

Float64

, 123)

@test always_false(rand(howmuch), rand(howmuch),123)

👀 Reading hidden code

3.2 ms

@bind howmuch Slider(0:100)

👀 Reading hidden code

143 ms

always_false(

Float64

0.228512

0.255628

Float64

0.654674

0.601017

, 123)

@test always_false(rand(2), rand(2),123)

👀 Reading hidden code

563 μs

true

@test !!always_false(rand(2), rand(2),123; r=123)

👀 Reading hidden code

31.1 ms

true

@test always_false([1,2,3]...)

👀 Reading hidden code

2.9 ms

isless(

, 1)

@test isless(2+2,1)

👀 Reading hidden code

3.1 ms

isless(1,

)

@test isless(1,2+2)

👀 Reading hidden code

496 μs

@bind n Slider(1:10)

👀 Reading hidden code

658 μs

iseven(

)

@test iseven(n^2)

👀 Reading hidden code

3.0 ms

@bind k Slider(0:15)

👀 Reading hidden code

574 μs

∈

Any

@test 4+4 ∈ [1:k...]

👀 Reading hidden code

11.0 ms

isempty(

Int64

)

@test isempty((1:k) .^ 2)

👀 Reading hidden code

66.1 ms

Main.workspace#3.TestResult

true

true

true

true

true

true

true

true

false

false

map(1:10) do i

@test sqrt($i) < 3 && always_false()

end

👀 Reading hidden code

102 ms

isempty(

Float64

1.0

1.41421

)

@test isempty([1,sqrt(2)])

👀 Reading hidden code

16.0 ms

1 ∈

Float64

4.47214

5.0

6.0

7.0

8.0

9.0

👀 Reading hidden code

32.8 ms

1 ∈

Float64

0.877185

0.577285

0.275266

0.276778

0.475851

0.557806

0.117438

0.0478049

0.882613

0.45402

0.688345

0.230317

0.931502

0.152388

0.840507

0.394254

0.654462

0.807972

0.432503

0.655838

0.727712

0.634316

0.668238

0.126186

0.184151

0.651291

0.220209

0.155677

0.511714

0.940578

👀 Reading hidden code

525 μs

Float64

0.303566

0.238192

0.851021

0.597958

0.746384

0.419846

0.682042

0.5853

0.159401

0.176118

0.699317

0.457702

0.267425

0.695037

0.127151

0.0753123

0.634633

0.729485

0.806144

0.927861

0.0985106

0.318337

0.154277

0.0458107

0.260618

0.525212

0.651604

0.613178

0.903134

0.636669

∋ 1

👀 Reading hidden code

8.6 ms

always_false (generic function with 1 method)

always_false(args...; kwargs...) = true

👀 Reading hidden code

1.1 ms

"pt-dot {\n\tflex: 0 0 auto;\n\tbackground: grey;\n\twidth: 1em;\n\theight: 1em;\n\tbottom: -.1em;\n\tborder-radius: 100%;\n\tmargin-right: .7em;\n\tdisplay: block;\n\tposition: relative;\n\tcursor: pointer;\n}\n\npt-dot.floating {\n\tposition: fixed;\n\tz-index: 60;\n\tvisibility: hidden;\n\ttransition: transform linear 120ms;\n" ⋯ 1338 bytes ⋯ "-frame-viewer {\n    max-width: 100%;\n}\n.pluto-test.expanded > p-frame-viewer > p-frames > slotted-code > line-like {\n\tflex-wrap: wrap;\n}\n.pluto-test.expanded > p-frame-viewer > p-frames > slotted-code > line-like > pluto-display[mime=\"application/vnd.pluto.tree+object\"] {\n\t/*flex-basis: 100%;*/\n}\n"

const pluto_test_css = """

pt-dot {

flex: 0 0 auto;

background: grey;

width: 1em;

height: 1em;

bottom: -.1em;

border-radius: 100%;

margin-right: .7em;

display: block;

position: relative;

cursor: pointer;

}

pt-dot.floating {

position: fixed;

z-index: 60;

visibility: hidden;

transition: transform linear 120ms;

opacity: .8;

}

.show-top-float > pt-dot.floating.top,

.show-bottom-float > pt-dot.floating.bottom {

visibility: visible;

}

pt-dot.floating.top {

top: 5px;

}

pt-dot.floating.bottom {

bottom: 5px;

}

.fail > pt-dot {

background: #f75d5d;

}

.pass > pt-dot {

background: #56a038;

}

@keyframes fadeout {

0% { opacity: 1;}

100% { opacity: 0; pointer-events: none;}

}

.pass > pt-dot.floating {

animation: fadeout 2s;

animation-fill-mode: both;

animation-delay: 2s;

/*opacity: 0.4;*/

}

.pluto-test {

font-family: "JuliaMono", monospace;

font-size: 0.75rem;

padding: 4px;

min-height: 25px;

}

.pluto-test.pass {

color: rgba(0,0,0,.5);

}

.pluto-test.fail {

background: linear-gradient(90deg, #ff2e2e14, transparent);

border-radius: 7px;

}

.pluto-test>.arg_result {

flex: 0 0 auto;

}

.pluto-test>.arg_result>div,

.pluto-test>.arg_result>div>pluto-display>div {

display: inline-flex;

}

.pluto-test>.comma {

margin-right: .5em;

}

.pluto-test.call>code {

padding: 0px;

}

.pluto-test.call.infix-operator>div {

overflow-x: auto;

}

.pluto-test {

display: flex;

align-items: baseline;

}

.pluto-test.call.infix-operator>.fname {

margin: 0px .6em;

/*color: darkred;*/

}

/* expanding */

.pluto-test:not(.expanded) > p-frame-viewer > p-frame-controls {

display: none;

}

.pluto-test.expanded > p-frame-viewer {

max-width: 100%;

}

.pluto-test.expanded > p-frame-viewer > p-frames > slotted-code > line-like {

flex-wrap: wrap;

}

.pluto-test.expanded > p-frame-viewer > p-frames > slotted-code > line-like > pluto-display[mime="application/vnd.pluto.tree+object"] {

/*flex-basis: 100%;*/

}

"""

👀 Reading hidden code

98.8 μs

"p-frame-viewer {\n\tdisplay: inline-flex;\n\tflex-direction: column;\n}\np-frames,\np-frame-controls {\n\tdisplay: inline-flex;\n}\n"

const frames_css = """

p-frame-viewer {

display: inline-flex;

flex-direction: column;

}

p-frames,

p-frame-controls {

display: inline-flex;

}

"""

👀 Reading hidden code

101 μs

using HypertextLiteral

👀 Reading hidden code

4.3 ms

# using PlutoUI

👀 Reading hidden code

7.9 μs

import Test

👀 Reading hidden code

149 μs

@test_deprecated (macro with 1 method)

begin

export @test_nowarn, @test_warn, @test_logs, @test_skip, @test_broken, @test_throws, @test_deprecated

var"@test_warn" = Test.var"@test_warn"

var"@test_nowarn" = Test.var"@test_nowarn"

var"@test_logs" = Test.var"@test_logs"

var"@test_skip" = Test.var"@test_skip"

var"@test_broken" = Test.var"@test_broken"

var"@test_throws" = Test.var"@test_throws"

var"@test_deprecated" = Test.var"@test_deprecated"

end

👀 Reading hidden code

445 μs

Type definitions

👀 Reading hidden code

180 μs

abstract type TestResult end

👀 Reading hidden code

360 μs

abstract type Fail <: TestResult end

👀 Reading hidden code

349 μs

abstract type Pass <: TestResult end

👀 Reading hidden code

323 μs

Any

const Code = Any

👀 Reading hidden code

103 μs

# struct Correct <: Pass

# expr::Code

# end

👀 Reading hidden code

8.9 μs

struct CorrectCall <: Pass

expr::Code

steps::Vector

end

👀 Reading hidden code

1.3 ms

# struct Error <: Fail

# expr::Code

# error

# end

👀 Reading hidden code

9.4 μs

# struct Wrong <: Fail

# expr::Code

# step

# end

👀 Reading hidden code

8.6 μs

struct WrongCall <: Fail

expr::Code

steps::Vector

end

👀 Reading hidden code

1.2 ms

Test macro

👀 Reading hidden code

171 μs

Main.workspace#3.CorrectCall

> 0.19

map(1:15) do i

@test 2 * $i > 0.19

end

👀 Reading hidden code

31.0 ms

step_by_step (generic function with 1 method)

function step_by_step(expr; __module__)

Computed

onestep_light

if can_interpret(expr)

quote

Any[$(QuoteNode(expr)), $(onestep_light)($(esc(Expr(:quote,expr))); m=$(__module__))...]

end

else

quote

[$(QuoteNode(expr)), Computed($(esc(expr)))]

end

👀 Reading hidden code

1.8 ms

test (generic function with 1 method)

function test(expr, extra_args...; __module__)

step_by_step

Test.test_expr!("", expr, extra_args...)

quote

expr_raw = $(QuoteNode(expr))

try

# steps = @eval_step_by_step($(expr))

steps = $(step_by_step(expr; __module__=__module__))

# arg_results = [$((expr.args[2:end] .|> esc)...)]

# result = $(esc(:eval))(Expr(:call, $(expr.args[1] |> QuoteNode), arg_results...))

result = unwrap_computed(last(steps))

if result === true

CorrectCall(expr_raw, steps)

# elseif result === false

# WrongCall(expr_raw, steps)

else

WrongCall(expr_raw, steps)

end

catch e

rethrow(e)

# Error(expr_raw, e)

end

👀 Reading hidden code

2.0 ms

👀 Reading hidden code

8.6 μs

begin
    var"#715#expr_raw" = $(QuoteNode(:(x == [1, 2 + i])))
    try
        var"#716#steps" = begin
                Main.workspace#6.Any[$(QuoteNode(:(x == [1, 2 + i]))), (Main.workspace#3.onestep_light)($(Expr(:copyast, :($(QuoteNode(:(x == [1, 2 + i])))))); m = Main.workspace#7)...]
            end
        var"#717#result" = Main.workspace#6.unwrap_computed(Main.workspace#6.last(var"#716#steps"))
        if var"#717#result" === true
            Main.workspace#6.CorrectCall(var"#715#expr_raw", var"#716#steps")
        else
            Main.workspace#6.WrongCall(var"#715#expr_raw", var"#716#steps")
        end
    catch var"#720#e"
        Main.workspace#6.rethrow(var"#720#e")
    end
end

var"@test"; macroexpand(@__MODULE__, :(@test x == [1,2+i]); recursive=false) |> prettycolors

👀 Reading hidden code

31.7 ms

always_false(

Float64

0.177692

0.0299733

0.199534

0.5229

0.549704

0.966359

0.652341

0.98215

0.787322

0.0531975

0.517717

0.580231

0.0221529

0.157678

0.363806

0.441299

0.013177

0.628578

0.00273435

0.183582

Float64

0.123697

0.0161145

0.311343

0.275197

0.486211

0.0224361

0.678502

0.219122

0.76761

0.231894

0.130068

0.679648

0.777732

0.461474

0.0565795

0.37392

0.761637

0.988155

0.276853

0.384182

, 123)

t = @test always_false(rand(20), rand(20),123)

👀 Reading hidden code

576 μs

begin

-4

false

end

@test begin

(1+2) - (3+4)

false

end

👀 Reading hidden code

2.9 ms

always_false(

Float64

0.745117

0.357617

0.588769

0.592227

0.872223

0.66986

0.152274

0.815722

0.606807

0.393058

0.979069

0.79169

0.246989

0.267678

0.154557

0.422457

0.29737

0.155406

0.43116

0.682777

0.750607

0.579246

0.19258

0.080015

0.83496

0.558147

0.315809

0.674432

0.569012

0.424698

, 123)

isa Fail

@test (@test always_false(rand(30),123)) isa Fail

👀 Reading hidden code

37.4 ms

false

embed_display(@test false)

👀 Reading hidden code

20.8 ms

always_false(

"asdasd"

, "asd",

"asd asd"

, "asd",

"asdasd"

, "asd",

"asdasd"

, "asd",

"asdasd"

, "asd",

"asdasd"

, "asd",

"asdasd"

, "asd")

@test always_false("asd"*"asd","asd","asd"*" asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd")

👀 Reading hidden code

18.8 ms

"asdasd"

"asd"

"asd asd"

"asd"

"asdasd"

"asd"

"asdasd"

"asd"

"asdasd"

"asd"

"asdasd"

"asd"

"asdasd"

"asd"

("asd"*"asd","asd","asd"*" asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd")

👀 Reading hidden code

24.1 μs

# @test (@test t isa Pass) isa Pass

👀 Reading hidden code

8.9 μs

true

@test π ≈ 3.14 atol=0.01 rtol=1

👀 Reading hidden code

38.5 ms

embed_display (generic function with 1 method)

embed_display = if isdefined(Main, :PlutoRunner) && isdefined(Main.PlutoRunner, :embed_display)

# if this package is used inside Pluto, and Pluto is new enough

Main.PlutoRunner.embed_display

else

identity

end

👀 Reading hidden code

35.8 μs

begin

export @test

macro test(expr...)

test(expr...; __module__=__module__)

end

function Base.show(io::IO, m::MIME"text/html", call::Union{WrongCall,CorrectCall})

infix = if Meta.isexpr(call.expr, :call)

fname = call.expr.args[1]

Meta.isbinaryoperator(fname)

else

false

end

classes = [

"pluto-test",

"call",

(isa(call,CorrectCall) ? "correct" : "wrong"),

(isa(call,Pass) ? "pass" : "fail"),

infix ? "infix-operator" : "prefix-operator",

]

result = @htl("""

const div = currentScript.parentElement

div.addEventListener("click", (e) => {

if(!div.classList.contains("expanded") || e.target.closest("pt-dot:not(.floating)") != null){

div.classList.toggle("expanded")

e.stopPropagation()

}

})

const throttled = (f, delay) => {

const waiting = { current: false }

return () => {

if (!waiting.current) {

f()

waiting.current = true

setTimeout(() => {

f()

waiting.current = false

}, delay)

}

const dot = div.querySelector("pt-dot")

const dot_top = div.querySelector("pt-dot.top")

const dot_bot = div.querySelector("pt-dot.bottom")

const intersect = (r) => {

const topdistance = r.top

const botdistance = window.visualViewport.height - r.bottom

const t = (x) => `translate(\${2*Math.sqrt(Math.max(0,-50-x))}px,0)`

dot_top.style.transform = t(topdistance)

dot_bot.style.transform = t(botdistance)

div.classList.toggle("show-top-float", topdistance < 4)

div.classList.toggle("show-bottom-float", botdistance < 4)

}

intersect(dot.getBoundingClientRect())

window.addEventListener("scroll", throttled(() => {

intersect(dot.getBoundingClientRect())

}, 100))

let observer = new IntersectionObserver((es) => {

const e = es[0]

intersect(e.boundingClientRect)

}, {

rootMargin: '-4px',

threshold: 1.0

});

observer.observe(dot)

invalidation.then(() => {

observer.unobserve(dot)

})

Array.from(div.querySelectorAll("pt-dot.floating")).forEach(e => {

e.addEventListener("click", () => dot.scrollIntoView({behavior: "smooth", block: "center", inline: "nearest"}))

})

</script>

<pt-dot></pt-dot>

<pt-dot class="floating top"></pt-dot>

<pt-dot class="floating bottom"></pt-dot>

$(frames(SlottedDisplay.( call.steps)))

</div>

<style>

$(pluto_test_css)

$(slotted_code_css)

</style>

""")

Base.show(io, m, result)

end

👀 Reading hidden code

2.0 ms

flatmap (generic function with 1 method)

flatmap(args...) = vcat(map(args...)...)

👀 Reading hidden code

454 μs

embed_display (generic function with 1 method)

emb = embed_display

👀 Reading hidden code

12.3 μs

div (generic function with 1 method)

div(x; class="", style="") = @htl("<div class=$(class) style=$(style)>$(x)</div>")

👀 Reading hidden code

462 ms

div (generic function with 2 methods)

div(; class="", style="") = x -> @htl("<div class=$(class) style=$(style)>$(x)</div>")

👀 Reading hidden code

1.9 ms

"x + 1"

expr_to_str(:(x+1))

👀 Reading hidden code

31.5 ms

expr_to_str (generic function with 2 methods)

expr_to_str(e, mod=@__MODULE__()) = let

Computed

sprint() do io

Base.print(IOContext(io, :module => @__MODULE__), remove_linenums(e))

end

👀 Reading hidden code

1.2 ms

prettycolors (generic function with 1 method)

prettycolors(e) = Markdown.MD([Markdown.Code("julia", expr_to_str(e))])

👀 Reading hidden code

470 μs

remove_linenums (generic function with 1 method)

remove_linenums(e::Expr) = if e.head === :macrocall

Expr(e.head, (remove_linenums(x) for x in e.args)...)

else

Expr(e.head, (remove_linenums(x) for x in e.args if !(x isa LineNumberNode))...)

end

👀 Reading hidden code

1.9 ms

remove_linenums (generic function with 2 methods)

remove_linenums(x) = x

👀 Reading hidden code

335 μs

UInt64

👀 Reading hidden code

2.2 ms

expr_hash (generic function with 1 method)

👀 Reading hidden code

1.1 ms

expr_hash (generic function with 2 methods)

👀 Reading hidden code

372 μs

Time travel evaluation

In Julia, expressions are objects! This means that, before evaluation, code is expressed as a Julia object:

👀 Reading hidden code

476 μs

:(first([56, sqrt(9)]))

ex1 = :(first([56,sqrt(9)]))

👀 Reading hidden code

30.2 μs

Expr
  head: Symbol call
  args: Array{Any}((2,))
    1: Symbol first
    2: Expr
      head: Symbol vect
      args: Array{Any}((2,))
        1: Int64 56
        2: Expr
          head: Symbol call
          args: Array{Any}((2,))
            1: Symbol sqrt
            2: Int64 9

Dump(ex1)

👀 Reading hidden code

106 ms

You can use Core.eval to evaluate expressions at runtime:

👀 Reading hidden code

194 μs

56.0

Core.eval(Module(), ex1)

👀 Reading hidden code

29.2 ms

But did you know that you can also partially evaluate expressions?

👀 Reading hidden code

284 μs

:([56, sqrt(9)])

ex2_inner = ex1.args[2]

👀 Reading hidden code

18.1 μs

Float64

56.0

3.0

ex2_inner_result = Core.eval(Module(), ex2_inner)

👀 Reading hidden code

339 μs

:(first([56.0, 3.0]))

ex2 = Expr(:call, :first, ex2_inner_result)

👀 Reading hidden code

17.2 μs

Expr
  head: Symbol call
  args: Array{Any}((2,))
    1: Symbol first
    2: Array{Float64}((2,)) [56.0, 3.0]

Dump(ex2)

👀 Reading hidden code

8.0 ms

Here, ex2 is not a raw Expr — it contains an evaluated array!

👀 Reading hidden code

229 μs

`Computed` struct

Our time travel mechanism will be based on the partial evaluation principle introduced above. To differentiate between computed results and the original expression, we will wrap all computed results in a struct.

👀 Reading hidden code

243 μs

struct Computed

end

👀 Reading hidden code

810 μs

:(first(Computed([56.0, 3.0])))

ex3 = Expr(:call, :first, Computed(ex2_inner_result))

👀 Reading hidden code

22.9 μs

Expr
  head: Symbol call
  args: Array{Any}((2,))
    1: Symbol first
    2: Main.workspace#3.Computed
      x: Array{Float64}((2,)) [56.0, 3.0]

Dump(ex3)

👀 Reading hidden code

70.1 μs

We also add a function to recursively unwrap an expression with Computed entries:

👀 Reading hidden code

222 μs

unwrap_computed (generic function with 1 method)

unwrap_computed(x) = x

👀 Reading hidden code

329 μs

unwrap_computed (generic function with 2 methods)

unwrap_computed(c::Computed) = c.x

👀 Reading hidden code

381 μs

unwrap_computed (generic function with 3 methods)

unwrap_computed(e::Expr) = Expr(e.head, unwrap_computed.(e.args)...)

👀 Reading hidden code

465 μs

:(first([56.0, 3.0]))

unwrap_computed(ex3)

👀 Reading hidden code

56.7 ms

Stepping function

👀 Reading hidden code

192 μs

Markdown.MD

begin
    sqrt(Computed(2.0)) + 2
end

begin
    Computed(1.4142135623730951) + 2
end

begin
    Computed(3.414213562373095)
end

Computed(3.414213562373095)

quote

sqrt(sqrt(4)) + 2

end |> onestep_light .|> prettycolors

👀 Reading hidden code

251 ms

onestep_light (generic function with 1 method)

function onestep_light(e::Expr; m=Module())::Vector

results = Any[]

seval(ex) = Computed(Core.eval(m,ex))

# will be modified

arg_results = Any[a for a in e.args]

push_intermediate() = push!(results, Expr(e.head, arg_results...))

# we only step for expressions where this is possible/easy

if e.head === :call || e.head === :begin || e.head === :block# || e.head === :vect

for (i,a) in enumerate(e.args)

if a isa QuoteNode

elseif (Meta.isexpr(e, :call) || Meta.isexpr(e, :let)) && i == 1

elseif a isa Symbol

arg_results[i] = seval(a)

push_intermediate()

elseif a isa Expr

inner_results = onestep_light(a; m=m)

for ir in inner_results

arg_results[i] = ir

push_intermediate()

end

arg_results[i] = inner_results[end]

else

end

push!(results, seval(unwrap_computed(Expr(e.head, arg_results...))))

results

end

👀 Reading hidden code

6.4 ms

onestep_light (generic function with 2 methods)

onestep_light(x::Any; m=Module()) = [Computed(Core.eval(m,x))]

👀 Reading hidden code

1.4 ms

md"""

"""

👀 Reading hidden code

121 μs

@eval_step_by_step (macro with 1 method)

macro eval_step_by_step(e)

step_by_step(e; __module__=__module__)

end

👀 Reading hidden code

534 μs

quote
    #= /home/runner/work/disorganised-mess/disorganised-mess/testing and debugging 3.jl#==#e1c306e3-0a47-4149-a9fb-ec7ab380fa11:6 =#
    Main.workspace#3.Any[$(QuoteNode(:(x == [1, 2]))), (Main.workspace#3.onestep_light)($(Expr(:copyast, :($(QuoteNode(:(x == [1, 2])))))); m = Main.workspace#4)...]
end

@macroexpand @eval_step_by_step x == [1,2]

👀 Reading hidden code

145 μs

Any

:(sqrt(sqrt(length([1, 2]))))

:(sqrt(sqrt(length(Computed([1, 2])))))

:(sqrt(sqrt(Computed(2))))

:(sqrt(Computed(1.41421)))

ComputedComputed

1.18921

@eval_step_by_step sqrt(sqrt(length([1,2])))

👀 Reading hidden code

39.3 ms

Any

:(xasdf = 123)

ComputedComputed

@eval_step_by_step xasdf = 123

👀 Reading hidden code

186 μs

Error message

UndefVarError: xasdf not defined

Stack trace

Here is what happened, the most recent locations are first:

from This cell: line 1
```
xasdf
```

xasdf

👀 Reading hidden code

---

Markdown.MD

begin
    Computed(3)
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

begin
    Computed(3)
    Computed(5)
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

begin
    Computed(3)
    Computed(5)
    Computed(9)
    sqrt(sqrt(sqrt(5)))
end

begin
    Computed(3)
    Computed(5)
    Computed(9)
    sqrt(sqrt(Computed(2.23606797749979)))
end

begin
    Computed(3)
    Computed(5)
    Computed(9)
    sqrt(Computed(1.4953487812212205))
end

begin
    Computed(3)
    Computed(5)
    Computed(9)
    Computed(1.2228445449938519)
end

Computed(1.2228445449938519)

onestep_light(quote

1+2

2+3

4+5

sqrt(sqrt(sqrt(5)))

end) .|> prettycolors

👀 Reading hidden code

19.8 ms

can_interpret (generic function with 1 method)

can_interpret(x) = true

👀 Reading hidden code

360 μs

can_interpret_call_arg (generic function with 1 method)

can_interpret_call_arg(e::Expr) = !(e.head === :(...) || e.head === :kw || e.head === :parameters)

👀 Reading hidden code

667 μs

can_interpret_call_arg (generic function with 2 methods)

can_interpret_call_arg(x) = true

👀 Reading hidden code

352 μs

true

Meta.isbinaryoperator(:(==))

👀 Reading hidden code

5.1 ms

can_interpret (generic function with 2 methods)

can_interpret(e::Expr) = if false

false

elseif e.head === :call && !all(can_interpret_call_arg, e.args)

false

# elseif e.head === :(=) || e.head === :macrocall

# false

else

all(can_interpret, e.args)

end

👀 Reading hidden code

642 μs

Displaying objects inside code

👀 Reading hidden code

179 μs

Slotting

We walk through the expression tree. Whenever we find a Computed object, we generate a random key (e.g. iosjddfo), we add it to our dictionary (found). In the expression, we replace the Computed object with a placeholder symbol __slotiosjddfo__. We will later be able to match the object to this slot.

👀 Reading hidden code

260 μs

slot! (generic function with 1 method)

slot!(found, c::Computed) = let

k = Symbol("__slot", join(rand('a':'z', 16)), "__")

found[k] = c

end

👀 Reading hidden code

573 μs

slot! (generic function with 2 methods)

slot!(found, x) = x

👀 Reading hidden code

362 μs

slot! (generic function with 3 methods)

slot!(found, e::Expr) = Expr(e.head, slot!.([found], e.args)...)

👀 Reading hidden code

511 μs

slot (generic function with 1 method)

slot(e) = let

d = Dict{Symbol,Any}()

new_e = slot!(d, e)

d, new_e

end

👀 Reading hidden code

538 μs

Tuple{Dict{Symbol, Any}, Any}

Dict{Symbol, Any}Dict

:__slotpjashjuaayxeuasy__

ComputedComputed

quote
    __slotpjashjuaayxeuasy__ + (7 - 6)
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

:__slotxttealnvgdxraxbc__

ComputedComputed

:__slotggigdjoatdpfffnc__

ComputedComputed

quote
    __slotggigdjoatdpfffnc__ + __slotxttealnvgdxraxbc__
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

:__slotacvtpkbtsjduxabs__

ComputedComputed

quote
    __slotacvtpkbtsjduxabs__
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

:__slotdckaushthmqaqmtb__

ComputedComputed

:__slotsuwejrfdjjpubroz__

ComputedComputed

quote
    __slotsuwejrfdjjpubroz__
    __slotdckaushthmqaqmtb__
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

:__slotsibqusrxknbzxnzt__

ComputedComputed

:__slotndvzvicmaogqpafz__

ComputedComputed

:__slottwpxonfelhdzlkkt__

ComputedComputed

quote
    __slotndvzvicmaogqpafz__
    __slotsibqusrxknbzxnzt__
    __slottwpxonfelhdzlkkt__
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

:__slotmkgnmedmufjkequb__

ComputedComputed

:__slotmshcqpkylqlihurt__

ComputedComputed

:__slottcycxiflssxynaeg__

ComputedComputed

:__slotmccabjwojqbcwwgg__

ComputedComputed

2.23607

quote
    __slotmshcqpkylqlihurt__
    __slotmkgnmedmufjkequb__
    __slottcycxiflssxynaeg__
    sqrt(sqrt(__slotmccabjwojqbcwwgg__))
end

Dict{Symbol, Any}Dict

:__slotxjuovedfnqfthnsd__

ComputedComputed

:__slotoilrzohvsemqjolq__

ComputedComputed

:__slotmpryfmjfndhxqkit__

ComputedComputed

:__slotaafdonjubicrduvj__

ComputedComputed

1.49535

quote
    __slotmpryfmjfndhxqkit__
    __slotxjuovedfnqfthnsd__
    __slotoilrzohvsemqjolq__
    sqrt(__slotaafdonjubicrduvj__)
end

Dict{Symbol, Any}Dict

:__slotpaidoknxlkslmafk__

ComputedComputed

:__slotzslqrmqghxungydo__

ComputedComputed

1.22284

:__slotjwkhalaszinsfwgl__

ComputedComputed

:__slotbxlefkztewexgeky__

ComputedComputed

quote
    __slotbxlefkztewexgeky__
    __slotjwkhalaszinsfwgl__
    __slotpaidoknxlkslmafk__
    __slotzslqrmqghxungydo__
end

Dict{Symbol, Any}Dict

:__slotmfkrzlgxybxupizv__

ComputedComputed

1.22284

:__slotmfkrzlgxybxupizv__

onestep_light(quote

(1+2) + (7-6)

2+3

4+5

sqrt(sqrt(sqrt(5)))

end |> remove_linenums) .|> slot

👀 Reading hidden code

414 ms

SlottedDisplay

We use print to turn the expression into source code.

For each line, we regex-search for slot variables, and we split the line around those. The code segments around slots are rendered inside <pre-ish> tags (like <pre> but inline), and the slots are replaced by embedded displays of the objects.

👀 Reading hidden code

335 μs

preish (generic function with 1 method)

preish(x) = @htl("<pre-ish>$(x)</pre-ish>")

👀 Reading hidden code

498 μs

SlottedDisplay

begin

struct SlottedDisplay

end

SlottedDisplay(expr) = SlottedDisplay(slot(expr)...)

end

👀 Reading hidden code

1.2 ms

function Base.show(io::IO, m::MIME"text/html", sd::SlottedDisplay)

d, e = sd.d, sd.e

s = sprint() do iobuffer

print(IOContext(iobuffer, io), e |> remove_linenums)

end

lines = split(s, "\n")

r = r"\_\_slot[a-z]{16}\_\_"

h = @htl("""<slotted-code>

map(lines) do l

keys = [Symbol(m.match) for m in eachmatch(r, l)]

rest = split(l, r; keepempty=true)

result = vcat((

[(isempty(r) ? @htl("") : preish(r)), embed_display(d[k].x)]

for (r,k) in zip(rest, keys)

)...)

push!(result, preish(last(rest)))

@htl("<line-like>$(result)</line-like>")

end

)

</slotted-code>""")

show(io, m, h)

end

👀 Reading hidden code

246 ms

"slotted-code {\n\tfont-family: \"JuliaMono\", monospace;\n\tfont-size: .75rem;\n\tdisplay: flex;\n\tflex-direction: column;\n}\npre-ish {\n\twhite-space: pre;\n}\n\nline-like {\n\tdisplay: flex;\n\talign-items: baseline;\n}\n"

const slotted_code_css = """

slotted-code {

font-family: "JuliaMono", monospace;

font-size: .75rem;

display: flex;

flex-direction: column;

}

pre-ish {

white-space: pre;

}

line-like {

display: flex;

align-items: baseline;

}

"""

👀 Reading hidden code

97.2 μs

plot (generic function with 1 method)

plot(args...; kwargs...) = Hannes

👀 Reading hidden code

1.1 ms

Error message

UndefVarError: plot not defined

Stack trace

Here is what happened, the most recent locations are first:

eval
from boot.jl:373

seval

from Other cell: line 4

	results = Any[]		seval(ex) = Computed(Core.eval(m,ex))		# will be modified

Show more...

rs = @eval_step_by_step(begin

(1+2) + (7-6)

plot(2000 .+ 30 .* rand(2+2))

4+5

sqrt(sqrt(sqrt(5)))

end) .|> SlottedDisplay

👀 Reading hidden code

---

Error message

Another cell defining rs contains errors.

@bind rindex Slider(eachindex(rs))

👀 Reading hidden code

---

Error message

Another cell defining rs and rindex contains errors.

rs[rindex]

👀 Reading hidden code

---

Frame viewer

A widget that takes a series of elements and displays them as 'video frames' with a timeline scrubber.

👀 Reading hidden code

213 μs

Error message

Another cell defining rs contains errors.

frames(rs)

👀 Reading hidden code

---

frames (generic function with 1 method)

function frames(fs::Vector)

l = length(fs)

startframe = l > 2 ? l - 1 : l

@htl("""

<p-frame-viewer>

<p-frames>

$(fs)

</p-frames>

<p-frame-controls>

</p-frame-controls>

const div = currentScript.parentElement

const input = div.querySelector("p-frame-controls > input.timescrub")

const frames = div.querySelector("p-frames")

const setviz = () => {

Array.from(frames.children).forEach((f,i) => {

f.style.display = i + 1 === input.valueAsNumber ? "inherit" : "none"

})

}

setviz()

input.addEventListener("input", setviz)

</script>

</p-frame-viewer>

<style>

$(frames_css)

</style>

""")

end

👀 Reading hidden code

920 μs

Macro to test frames

👀 Reading hidden code

177 μs

@visual_debug (macro with 1 method)

macro visual_debug(expr)

frames

SlottedDisplay

var"@eval_step_by_step"

quote

@eval_step_by_step($(expr)) .|> SlottedDisplay |> frames

end

👀 Reading hidden code

595 μs

Error message

UndefVarError: plot not defined

Stack trace

Here is what happened, the most recent locations are first:

eval
from boot.jl:373

seval

from Other cell: line 4

	results = Any[]		seval(ex) = Computed(Core.eval(m,ex))		# will be modified

Show more...

@visual_debug begin

(1+2) + (7-6)

plot(2000 .+ 30 .* rand(2+2))

4+5

sqrt(sqrt(sqrt(5)))

end

👀 Reading hidden code

---

👀 Reading hidden code

66.8 μs

Appendix

👀 Reading hidden code

165 μs

DisplayOnly

👀 Reading hidden code

161 μs

is_inside_pluto (generic function with 1 method)

👀 Reading hidden code

631 μs

@skip_as_script

@displayonly expression

Marks a expression as Pluto-only, which means that it won't be executed when running outside Pluto. Do not use this for your own projects.

👀 Reading hidden code

807 μs

@only_as_script

The opposite of @skip_as_script

👀 Reading hidden code

825 μs

"hello"

@skip_as_script "hello"

👀 Reading hidden code

10.2 ms

PlutoUI favourites

👀 Reading hidden code

179 μs

"@media screen and (min-width: 1081px) {\n\t.plutoui-toc.aside {\n\t\tposition:fixed; \n\t\tright: 1rem;\n\t\ttop: 5rem; \n\t\twidth:25%; \n\t\tpadding: 10px;\n\t\tborder: 3px solid rgba(0, 0, 0, 0.15);\n\t\tborder-radius: 10px;\n\t\tbox-shadow: 0 0 11px 0px #00000010;\n\t\t/* That is, viewport minus top minus Live Docs */\n\t\tma" ⋯ 790 bytes ⋯ " 0px;\n}\n.plutoui-toc.indent section a.H2 {\n\tpadding-left: 10px;\n}\n.plutoui-toc.indent section a.H3 {\n\tpadding-left: 20px;\n}\n.plutoui-toc.indent section a.H4 {\n\tpadding-left: 30px;\n}\n.plutoui-toc.indent section a.H5 {\n\tpadding-left: 40px;\n}\n.plutoui-toc.indent section a.H6 {\n\tpadding-left: 50px;\n}\n"

👀 Reading hidden code

97.4 μs

#1 (generic function with 1 method)

👀 Reading hidden code

652 μs

toc (generic function with 1 method)

👀 Reading hidden code

528 μs

Slider

👀 Reading hidden code

11.5 ms

Dump (generic function with 1 method)

👀 Reading hidden code

1.8 ms

Base.RefValue{Int64}
  x: Int64 1

Dump(Ref(1))

👀 Reading hidden code

5.1 ms

Show

👀 Reading hidden code

2.6 ms

👀 Reading hidden code

68.2 μs

In the cloud (experimental)

On your computer

Frontmatter

Preview

PlutoTest.jl

Time travel

(You need `Pluto#main` to run this notebook)

Type definitions

Test macro

Time travel evaluation

`Computed` struct

Stepping function

Displaying objects inside code

Slotting

SlottedDisplay

Frame viewer

Macro to test frames

Appendix

DisplayOnly

PlutoUI favourites

PlutoTest.jl

Time travel

(You need Pluto#main to run this notebook)

Type definitions

Test macro

Time travel evaluation

Computed struct

Stepping function

Displaying objects inside code

Slotting

SlottedDisplay

Frame viewer

Macro to test frames

Appendix

DisplayOnly

PlutoUI favourites

(You need `Pluto#main` to run this notebook)

`Computed` struct